/**
 * 判断要查询的数组是否至少有一个元素包含在目标数组中
 *
 * @param  {[type]} target [description]
 * @param  {[type]} arr    [description]
 * @return {[type]}        [description]
 */
export const hasOneOf = (target, arr) => {
	return target.some(_ => arr.indexOf(_) > -1)
}

/**
 * 得到两个数组的交集, 两个数组的元素为数值或字符串
 *
 * @param  {[type]} arr1 [description]
 * @param  {[type]} arr2 [description]
 * @return {[type]}      [description]
 */
export const getIntersection = (arr1, arr2) => {
	let len = Math.min(arr1.length, arr2.length)
	let i = -1
	let res = []
	while (++i < len) {
		const item = arr2[i]
		if (arr1.indexOf(item) > -1) res.push(item)
	}
	return res
}

/*删除其中一个元素*/
function remove(arr, ele) {
	var index = arr.indexOf(ele);
	if (index > -1) {
		arr.splice(index, 1);
	}
	return arr;
}

/**
 * 得到两个数组的并集, 两个数组的元素为数值或字符串
 *
 * @param  {[type]} arr1 [description]
 * @param  {[type]} arr2 [description]
 * @return {[type]}      [description]
 */
export const getUnion = (arr1, arr2) => {
	return Array.from(new Set([...arr1, ...arr2]))
}


//数组去重1
export const removeDuplicate1 = function(arr) {
	return arr.filter(function(item, index, self) {
		return self.indexOf(item) === index
	})
}

//数组去重2
export const removeDuplicate2 = function(arr) {
	return [...new Set(arr)]
}

// 得到数组的最大值
export const getArrMax = function(arr) {
	return Math.max.apply(null, arr);
}

//得到数组的最小值
export const getArrMin = function(arr) {
	return Math.min.apply(null, arr);
}

// 求和
export const sumArr = function(arr) {
	return arr.reduce(function(previous, current) {
		return previous + current
	})
}

// 求平均值
export const avgArr = function(arr) {
	return this.sumArr(arr) / arr.length;
}

/* 数字数组排序 */
function(arr) {
	return arr.sort(function(a1, a2) {
		return a1 - a2; //从小到大
		//return a2-a1;//从大到小
	})
}

/* 汉字数组按拼音首字母排序 */
var arr = ['阿', '字', '排', '首']
arr = arr.sort(function(a, b) { //排序
	return a.localeCompare(b, "zh")
})

/* 去除数组重复项 */
function unique(arr) { //使用indexOf判断临时数组中是否存在数组中的值
	var tmp = [];
	for (var i = 0; i < arr.length; i++) {
		if (tmp.indexOf(arr[i]) < 0) {
			tmp.push(arr[i])
		}
	}
	return tmp;
}
/* 另一种 */
function unique2(arr) { //使用ES6的Set()方法,需ES6环境
	var set = new Set(arr);
	//return Array.from(set); //将Set对象转化为数组
	return [...set] //将Set对象转化为数组
}

/* 数组随机排列 */
function(arr) {
	var newArr = [],
		res = []
	for (var i = 0; i < arr.length; i++) {
		newArr[i] = {}
		newArr[i].r = Math.random()
		newArr[i].a = arr[i]
	}
	newArr.sort(function(a, b) {
		return a.r - b.r
	})
	for (item of newArr) {
		res.push(item.a)
	}
	return res
}

//从数组中随机获取元素
function randomOne(arr) {
	return arr[Math.floor(Math.random() * arr.length)];
}

/**
 * 把数字字符串数组转换为数字数组
 * @param arr 数组
 * @returns {Array}
 */
function strToNum(arr) {
	var json = [];
	for (var i = 0; i < arr.length; i++) {
		json.push(arr[i] - 0);
	}
	return json;
}

/* 根据数组项中某个共有字段分组 */
/* forEach(fn) ES6代替for循环 */
var arr = [{
		"id": "1001",
		"name": "值1",
		"value": "111"
	},
	{
		"id": "1001",
		"name": "值1",
		"value": "11111"
	},
	{
		"id": "1002",
		"name": "值2",
		"value": "25462"
	},
	{
		"id": "1002",
		"name": "值2",
		"value": "23131"
	},
	{
		"id": "1002",
		"name": "值2",
		"value": "2315432"
	},
	{
		"id": "1003",
		"name": "值3",
		"value": "333333"
	}
]
var map = {},
	dest = []
arr.forEach(function(item1) {
	if (!map[item1.id]) {
		dest.push({
			id: item1.id,
			name: item1.name,
			data: [item1]
		});
		map[item1.id] = item1;
	} else {
		dest.forEach(function(item2) {
			if (item2.id == item1.id && !item2.data.includes(item1)) {
				item2.data.push(item1);
			}
		})
	}
})

//将类数组转换为数组(在之前都用的循环push)
//类数组：set数据、arguments、元素组nodeList、字符串等等
let set = new Set(['a', 'b', 'c'])
console.log([...set]) //[ 'a', 'b', 'c' ]

//将类数组转换为数组另一种方法Array.from()
//需要注意：IE支持的版本较少
let arg = function() {
		return arguments
	},
	str = '字符串'
console.log(Array.from(arg('a', 'b', 'c'))) //[ 'a', 'b', 'c' ]
console.log(Array.from(str)) //[ '字', '符', '串' ]
console.log(str.split('')) //字符串自带方法--[ '字', '符', '串' ]

//将类数组转换为数组另一种方法(原生)：[].slice.call()
Array.prototype.slice.call(str) //[ '字', '符', '串' ]
//或者
[].slice.call(str) //[ '字', '符', '串' ]

//类数组使用数组的forEach循环方法
Array.prototype.forEach.call(str, function(item) {
	console.log(item) //结果：连续输出：字、符、串
})

//求数组差集
let diff = arr1.filter(function(val) {
	return arr2.indexOf(val) === -1
})

//元素交换位置
function swapArr(arr, index1, index2) {
	arr[index1] = arr.splice(index2, 1, arr[index1])[0];
	return arr;
}

//元素移动到某元素之前(元素是对象，对象含唯一识别ID)
function arrItemMoveBefore(arr, currIndex, beforeItemIndex) {
	// 缓存目标元素
	const beforeItem = arr[beforeItemIndex];

	// 删除此元素，且缓存
	const delItem = arr.splice(currIndex, 1)[0]

	// 目标元素现在位置
	const beforeItemIndexNew = arr.findIndex(({
		id
	}) => id === beforeItem.id)

	// 插入目标元素之前
	arr.splice(beforeItemIndexNew, 0, delItem)

	return arr;
}

//元素移动到某元素之后(元素是对象，对象含唯一识别ID)
function arrItemMoveAfter(arr, currIndex, afterItemIndex) {
	// 缓存目标元素
	const afterItem = arr[afterItemIndex];

	// 删除此元素，且缓存
	const delItem = arr.splice(currIndex, 1)[0]

	// 目标元素现在位置
	const afterItemIndexNew = arr.findIndex(({
		id
	}) => id === afterItem.id)

	// 插入目标元素之后
	arr.splice(afterItemIndexNew + 1, 0, delItem)

	return arr;
}

//元素置顶
function toFirst(fieldData, index) {
	if (index != 0) {
		fieldData.unshift(fieldData.splice(index, 1)[0]);
	}
}

//元素置底部
function toLast(fieldData, index) {
	if (index != 0) {
		fieldData.push(fieldData.splice(index, 1)[0]);
	}
}

//元素上移
function upGo(fieldData, index) {
	if (index != 0) {
		fieldData[index] = fieldData.splice(index - 1, 1, fieldData[index])[0];
	} else {
		fieldData.push(fieldData.shift());
	}
}
//元素下移
function downGo(fieldData, index) {
	if (index != fieldData.length - 1) {
		fieldData[index] = fieldData.splice(index + 1, 1, fieldData[index])[0];
	} else {
		fieldData.unshift(fieldData.splice(index, 1)[0]);
	}
}
